var express = require('express');
var router = express.Router();
var {ltcModel,essayModel,commentsModel} = require('../db/ltc');

/* GET users listing. */
router.get('/', function(req, res, next) {
  res.send('respond with a resource');
});

router.get('/essay', async function(req, res, next) {
    const essayData = await essayModel.find({});
    console.log(essayData);
    res.json({
      code: 200,
      msg: '获取动态数据成功',
      data: essayData
    });
  });

// 添加评论接口
router.post('/comments/add', async function(req, res, next) {
    try {
        const { content, essayId, author, parentId, replyTo } = req.body;
        
        console.log('收到评论请求:', { content, essayId, author, parentId, replyTo });
        
        // 验证必需字段
        if (!content || !essayId || !author) {
            console.log('缺少必需字段:', { content: !!content, essayId: !!essayId, author: !!author });
            return res.json({
                code: 400,
                msg: '缺少必需字段',
                data: null
            });
        }
        
        // 验证文章是否存在
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            console.log('文章不存在:', essayId);
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        console.log('找到文章:', essay._id);
        
        // 创建评论
        const newComment = new commentsModel({
            content: content.trim(),
            essayId: essayId,
            author: {
                _id: author._id,
                name: author.name
            },
            like: [], // 初始化为空数组
            parentId: parentId || null,
            replyTo: replyTo || null
        });
        
        console.log('准备保存评论:', newComment);
        
        const savedComment = await newComment.save();
        console.log('评论保存成功:', savedComment._id);
        
        // 更新文章的评论数
        try {
            await essayModel.findByIdAndUpdate(essayId, {
                $inc: { comments: 1 }
            });
            console.log('文章评论数更新成功');
        } catch (updateError) {
            console.error('更新评论数失败:', updateError);
            // 即使更新评论数失败，评论本身已经保存成功
        }
        
        res.json({
            code: 200,
            msg: '评论添加成功',
            data: savedComment
        });
        
    } catch (error) {
        console.error('添加评论失败 - 详细错误:', error);
        console.error('错误堆栈:', error.stack);
        
        // 如果错误发生在评论保存之后，说明评论已经保存成功
        if (error.message && error.message.includes('$inc')) {
            res.json({
                code: 200,
                msg: '评论添加成功（评论数更新失败）',
                data: null
            });
        } else {
            res.json({
                code: 500,
                msg: '服务器内部错误: ' + error.message,
                data: null
            });
        }
    }
});

// 获取评论列表接口
router.get('/comments/list', async function(req, res, next) {
    try {
        const { essayId } = req.query;
        
        if (!essayId) {
            return res.json({
                code: 400,
                msg: '缺少文章ID参数',
                data: null
            });
        }
        
        // 验证文章是否存在
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        // 获取评论列表
        const comments = await commentsModel.find({ essayId: essayId })
            .sort({ createdata: -1 });
        
        res.json({
            code: 200,
            msg: '获取评论成功',
            data: comments
        });
        
    } catch (error) {
        console.error('获取评论失败:', error);
        res.json({
            code: 500,
            msg: '服务器内部错误',
            data: null
        });
    }
});

// 更新浏览量接口
router.post('/updateViews', async function(req, res, next) {
    try {
        const { essayId } = req.body;
        
        console.log('收到浏览量更新请求:', { essayId });
        
        // 验证必需字段
        if (!essayId) {
            console.log('缺少文章ID');
            return res.json({
                code: 400,
                msg: '缺少文章ID',
                data: null
            });
        }
        
        // 验证ObjectId格式
        if (!require('mongoose').Types.ObjectId.isValid(essayId)) {
            console.log('无效的文章ID格式:', essayId);
            return res.json({
                code: 400,
                msg: '无效的文章ID格式',
                data: null
            });
        }
        
        // 验证文章是否存在
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            console.log('文章不存在:', essayId);
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        console.log('找到文章:', essay._id, '当前浏览量:', essay.views);
        
        // 更新浏览量
        const updatedEssay = await essayModel.findByIdAndUpdate(
            essayId, 
            { $inc: { views: 1 } }, 
            { new: true }
        );
        
        console.log('浏览量更新成功，新浏览量:', updatedEssay.views);
        
        res.json({
            code: 200,
            msg: '浏览量更新成功',
            data: {
                essayId: essayId,
                views: updatedEssay.views
            }
        });
        
    } catch (error) {
        console.error('更新浏览量失败:', error);
        res.json({
            code: 500,
            msg: '服务器内部错误: ' + error.message,
            data: null
        });
    }
});

// 评论点赞/取消点赞接口
router.post('/comments/like', async function(req, res, next) {
    try {
        const { commentId, userId } = req.body;
        
        console.log('收到点赞请求:', { commentId, userId });
        
        // 验证必需字段
        if (!commentId || !userId) {
            console.log('缺少必需字段:', { commentId: !!commentId, userId: !!userId });
            return res.json({
                code: 400,
                msg: '缺少必需字段',
                data: null
            });
        }
        
        // 验证ObjectId格式
        if (!require('mongoose').Types.ObjectId.isValid(commentId) || !require('mongoose').Types.ObjectId.isValid(userId)) {
            console.log('无效的ID格式');
            return res.json({
                code: 400,
                msg: '无效的ID格式',
                data: null
            });
        }
        
        // 查找评论
        const comment = await commentsModel.findById(commentId);
        if (!comment) {
            console.log('评论不存在:', commentId);
            return res.json({
                code: 404,
                msg: '评论不存在',
                data: null
            });
        }
        
        console.log('找到评论:', comment._id, '当前点赞用户:', comment.like);
        
        // 检查用户是否已经点赞
        const isLiked = comment.like.includes(userId);
        
        let updatedComment;
        if (isLiked) {
            // 取消点赞：从数组中移除用户ID
            updatedComment = await commentsModel.findByIdAndUpdate(
                commentId,
                { $pull: { like: userId } },
                { new: true }
            );
            console.log('取消点赞成功');
        } else {
            // 添加点赞：将用户ID添加到数组
            updatedComment = await commentsModel.findByIdAndUpdate(
                commentId,
                { $addToSet: { like: userId } },
                { new: true }
            );
            console.log('添加点赞成功');
        }
        
        console.log('更新后点赞用户:', updatedComment.like);
        
        res.json({
            code: 200,
            msg: isLiked ? '取消点赞成功' : '点赞成功',
            data: {
                commentId: commentId,
                userId: userId,
                likeCount: updatedComment.like.length,
                isLiked: !isLiked
            }
        });
        
    } catch (error) {
        console.error('点赞操作失败:', error);
        res.json({
            code: 500,
            msg: '服务器内部错误: ' + error.message,
            data: null
        });
    }
});

// 文章点赞/取消点赞接口
router.post('/essay/like', async function(req, res, next) {
    try {
        const { essayId, userId } = req.body;
        
        console.log('收到文章点赞请求:', { essayId, userId });
        
        // 验证必需字段
        if (!essayId || !userId) {
            console.log('缺少必需字段:', { essayId: !!essayId, userId: !!userId });
            return res.json({
                code: 400,
                msg: '缺少必需字段',
                data: null
            });
        }
        
        // 验证ObjectId格式
        if (!require('mongoose').Types.ObjectId.isValid(essayId) || !require('mongoose').Types.ObjectId.isValid(userId)) {
            console.log('无效的ID格式');
            return res.json({
                code: 400,
                msg: '无效的ID格式',
                data: null
            });
        }
        
        // 查找文章
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            console.log('文章不存在:', essayId);
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        console.log('找到文章:', essay._id, '当前点赞用户:', essay.likes);
        
        // 检查用户是否已经点赞
        const isLiked = essay.likes && essay.likes.includes(userId);
        
        let updatedEssay;
        if (isLiked) {
            // 取消点赞：从数组中移除用户ID
            updatedEssay = await essayModel.findByIdAndUpdate(
                essayId,
                { $pull: { likes: userId } },
                { new: true }
            );
            console.log('取消文章点赞成功');
        } else {
            // 添加点赞：将用户ID添加到数组
            updatedEssay = await essayModel.findByIdAndUpdate(
                essayId,
                { $addToSet: { likes: userId } },
                { new: true }
            );
            console.log('添加文章点赞成功');
        }
        
        console.log('更新后点赞用户:', updatedEssay.likes);
        
        res.json({
            code: 200,
            msg: isLiked ? '取消点赞成功' : '点赞成功',
            data: {
                essayId: essayId,
                userId: userId,
                likeCount: updatedEssay.likes ? updatedEssay.likes.length : 0,
                isLiked: !isLiked
            }
        });
        
    } catch (error) {
        console.error('文章点赞操作失败:', error);
        res.json({
            code: 500,
            msg: '服务器内部错误: ' + error.message,
            data: null
        });
    }
});

// 获取文章点赞状态接口
router.get('/essay/likeStatus', async function(req, res, next) {
    try {
        const { essayId, userId } = req.query;
        
        console.log('获取文章点赞状态:', { essayId, userId });
        
        // 验证必需字段
        if (!essayId) {
            console.log('缺少文章ID');
            return res.json({
                code: 400,
                msg: '缺少文章ID',
                data: null
            });
        }
        
        // 验证ObjectId格式
        if (!require('mongoose').Types.ObjectId.isValid(essayId)) {
            console.log('无效的文章ID格式');
            return res.json({
                code: 400,
                msg: '无效的文章ID格式',
                data: null
            });
        }
        
        // 查找文章
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            console.log('文章不存在:', essayId);
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        // 检查用户是否已点赞
        const isLiked = userId && essay.likes && essay.likes.includes(userId);
        const likeCount = essay.likes ? essay.likes.length : 0;
        
        console.log('文章点赞状态:', { essayId, isLiked, likeCount });
        
        res.json({
            code: 200,
            msg: '获取成功',
            data: {
                essayId: essayId,
                isLiked: isLiked,
                likeCount: likeCount
            }
        });
        
    } catch (error) {
        console.error('获取文章点赞状态失败:', error);
        res.json({
            code: 500,
            msg: '服务器内部错误: ' + error.message,
            data: null
        });
    }
});

// 删除评论接口
router.post('/comments/delete', async function(req, res, next) {
    try {
        const { commentId, essayId } = req.body;
        
        console.log('收到删除评论请求:', { commentId, essayId });
        
        // 验证必需字段
        if (!commentId || !essayId) {
            console.log('缺少必需字段:', { commentId: !!commentId, essayId: !!essayId });
            return res.json({
                code: 400,
                msg: '缺少必需字段',
                data: null
            });
        }
        
        // 验证ObjectId格式
        if (!require('mongoose').Types.ObjectId.isValid(commentId) || 
            !require('mongoose').Types.ObjectId.isValid(essayId)) {
            console.log('无效的ID格式');
            return res.json({
                code: 400,
                msg: '无效的ID格式',
                data: null
            });
        }
        
        // 验证评论是否存在
        const comment = await commentsModel.findById(commentId);
        if (!comment) {
            console.log('评论不存在:', commentId);
            return res.json({
                code: 404,
                msg: '评论不存在',
                data: null
            });
        }
        
        // 验证文章是否存在
        const essay = await essayModel.findById(essayId);
        if (!essay) {
            console.log('文章不存在:', essayId);
            return res.json({
                code: 404,
                msg: '文章不存在',
                data: null
            });
        }
        
        console.log('找到评论和文章，准备删除评论');
        
        // 删除评论
        await commentsModel.findByIdAndDelete(commentId);
        console.log('评论删除成功:', commentId);
        
        // 更新文章的评论数
        try {
            await essayModel.findByIdAndUpdate(essayId, {
                $inc: { comments: -1 }
            });
            console.log('文章评论数更新成功');
        } catch (updateError) {
            console.error('更新评论数失败:', updateError);
            // 即使更新评论数失败，评论本身已经删除成功
        }
        
        res.json({
            code: 200,
            msg: '评论删除成功',
            data: {
                commentId: commentId,
                essayId: essayId
            }
        });
        
    } catch (error) {
        console.error('删除评论失败 - 详细错误:', error);
        console.error('错误堆栈:', error.stack);
        
        res.json({
            code: 500,
            msg: '服务器内部错误: ' + error.message,
            data: null
        });
    }
});

// 获取动态列表接口
router.get('/essay/list', async function(req, res, next) {
    const essayData = await essayModel.find({});
    res.json({
      code: 200,
      msg: '获取动态列表成功',
      data: essayData
    });
  });
module.exports = router;
